home *** CD-ROM | disk | FTP | other *** search
/ Inter.Net 55-1 / Inter.Net 55-1.iso / CBuilder / Setup / BCB / data.z / wdbgexts.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-02-09  |  13.1 KB  |  532 lines
  1. /*++
  2.  
  3. Copyright (c) 1992-1996  Microsoft Corporation
  4.  
  5. Module Name:
  6.  
  7.     wdbgexts.h
  8.  
  9. Abstract:
  10.  
  11.     This file contains the necessary prototypes and data types for a user
  12.     to write a debugger extension DLL.  This header file is also included
  13.     by the NT debuggers (WINDBG & KD).
  14.  
  15.     This header file must be included after "windows.h" and "imagehlp.h".
  16.  
  17.     Please see the NT DDK documentation for specific information about
  18.     how to write your own debugger extension DLL.
  19.  
  20. Environment:
  21.  
  22.     Win32 only.
  23.  
  24. Revision History:
  25.  
  26. --*/
  27.  
  28. #ifndef _WDBGEXTS_
  29. #define _WDBGEXTS_
  30. #pragma option push -b
  31.  
  32. #ifdef __BORLANDC__
  33. #  include <pshpack8.h>
  34. #endif
  35.  
  36. #ifdef __cplusplus
  37. extern "C" {
  38. #endif
  39.  
  40. #if !defined(WDBGAPI)
  41. #define WDBGAPI __stdcall
  42. #endif
  43.  
  44. #ifndef _WINDEF_
  45. typedef CONST void far *LPCVOID;
  46. #endif
  47.  
  48. typedef DWORDLONG ULONGLONG;
  49.  
  50.  
  51. typedef
  52. VOID
  53. (WDBGAPI*PWINDBG_OUTPUT_ROUTINE)(
  54.     PCSTR lpFormat,
  55.     ...
  56.     );
  57.  
  58. typedef
  59. ULONG
  60. (WDBGAPI*PWINDBG_GET_EXPRESSION)(
  61.     PCSTR lpExpression
  62.     );
  63.  
  64. typedef
  65. VOID
  66. (WDBGAPI*PWINDBG_GET_SYMBOL)(
  67.     PVOID   offset,
  68.     PUCHAR  pchBuffer,
  69.     PULONG  pDisplacement
  70.     );
  71.  
  72. typedef
  73. ULONG
  74. (WDBGAPI*PWINDBG_DISASM)(
  75.     PULONG lpOffset,
  76.     PCSTR  lpBuffer,
  77.     ULONG  fShowEffectiveAddress
  78.     );
  79.  
  80. typedef
  81. ULONG
  82. (WDBGAPI*PWINDBG_CHECK_CONTROL_C)(
  83.     VOID
  84.     );
  85.  
  86. typedef
  87. ULONG
  88. (WDBGAPI*PWINDBG_READ_PROCESS_MEMORY_ROUTINE)(
  89.     ULONG  offset,
  90.     PVOID  lpBuffer,
  91.     ULONG  cb,
  92.     PULONG lpcbBytesRead
  93.     );
  94.  
  95. typedef
  96. ULONG
  97. (WDBGAPI*PWINDBG_WRITE_PROCESS_MEMORY_ROUTINE)(
  98.     ULONG   offset,
  99.     LPCVOID lpBuffer,
  100.     ULONG   cb,
  101.     PULONG  lpcbBytesWritten
  102.     );
  103.  
  104. typedef
  105. ULONG
  106. (WDBGAPI*PWINDBG_GET_THREAD_CONTEXT_ROUTINE)(
  107.     ULONG       Processor,
  108.     PCONTEXT    lpContext,
  109.     ULONG       cbSizeOfContext
  110.     );
  111.  
  112. typedef
  113. ULONG
  114. (WDBGAPI*PWINDBG_SET_THREAD_CONTEXT_ROUTINE)(
  115.     ULONG       Processor,
  116.     PCONTEXT    lpContext,
  117.     ULONG       cbSizeOfContext
  118.     );
  119.  
  120. typedef
  121. ULONG
  122. (WDBGAPI*PWINDBG_IOCTL_ROUTINE)(
  123.     USHORT   IoctlType,
  124.     PVOID    lpvData,
  125.     ULONG    cbSize
  126.     );
  127.  
  128. typedef
  129. ULONG
  130. (WDBGAPI*PWINDBG_OLDKD_READ_PHYSICAL_MEMORY)(
  131.     LARGE_INTEGER    address,
  132.     PVOID            buffer,
  133.     ULONG            count,
  134.     PULONG           bytesread
  135.     );
  136.  
  137. typedef
  138. ULONG
  139. (WDBGAPI*PWINDBG_OLDKD_WRITE_PHYSICAL_MEMORY)(
  140.     LARGE_INTEGER    address,
  141.     PVOID            buffer,
  142.     ULONG            length,
  143.     PULONG           byteswritten
  144.     );
  145.  
  146.  
  147. typedef struct _tagEXTSTACKTRACE {
  148.     ULONG       FramePointer;
  149.     ULONG       ProgramCounter;
  150.     ULONG       ReturnAddress;
  151.     ULONG       Args[4];
  152. } EXTSTACKTRACE, *PEXTSTACKTRACE;
  153.  
  154.  
  155. typedef
  156. ULONG
  157. (*PWINDBG_STACKTRACE_ROUTINE)(
  158.     ULONG             FramePointer,
  159.     ULONG             StackPointer,
  160.     ULONG             ProgramCounter,
  161.     PEXTSTACKTRACE    StackFrames,
  162.     ULONG             Frames
  163.     );
  164.  
  165. typedef struct _WINDBG_EXTENSION_APIS {
  166.     ULONG                                  nSize;
  167.     PWINDBG_OUTPUT_ROUTINE                 lpOutputRoutine;
  168.     PWINDBG_GET_EXPRESSION                 lpGetExpressionRoutine;
  169.     PWINDBG_GET_SYMBOL                     lpGetSymbolRoutine;
  170.     PWINDBG_DISASM                         lpDisasmRoutine;
  171.     PWINDBG_CHECK_CONTROL_C                lpCheckControlCRoutine;
  172.     PWINDBG_READ_PROCESS_MEMORY_ROUTINE    lpReadProcessMemoryRoutine;
  173.     PWINDBG_WRITE_PROCESS_MEMORY_ROUTINE   lpWriteProcessMemoryRoutine;
  174.     PWINDBG_GET_THREAD_CONTEXT_ROUTINE     lpGetThreadContextRoutine;
  175.     PWINDBG_SET_THREAD_CONTEXT_ROUTINE     lpSetThreadContextRoutine;
  176.     PWINDBG_IOCTL_ROUTINE                  lpIoctlRoutine;
  177.     PWINDBG_STACKTRACE_ROUTINE             lpStackTraceRoutine;
  178. } WINDBG_EXTENSION_APIS, *PWINDBG_EXTENSION_APIS;
  179.  
  180. typedef struct _WINDBG_OLD_EXTENSION_APIS {
  181.     ULONG                                  nSize;
  182.     PWINDBG_OUTPUT_ROUTINE                 lpOutputRoutine;
  183.     PWINDBG_GET_EXPRESSION                 lpGetExpressionRoutine;
  184.     PWINDBG_GET_SYMBOL                     lpGetSymbolRoutine;
  185.     PWINDBG_DISASM                         lpDisasmRoutine;
  186.     PWINDBG_CHECK_CONTROL_C                lpCheckControlCRoutine;
  187. } WINDBG_OLD_EXTENSION_APIS, *PWINDBG_OLD_EXTENSION_APIS;
  188.  
  189. typedef struct _WINDBG_OLDKD_EXTENSION_APIS {
  190.     ULONG                                  nSize;
  191.     PWINDBG_OUTPUT_ROUTINE                 lpOutputRoutine;
  192.     PWINDBG_GET_EXPRESSION                 lpGetExpressionRoutine;
  193.     PWINDBG_GET_SYMBOL                     lpGetSymbolRoutine;
  194.     PWINDBG_DISASM                         lpDisasmRoutine;
  195.     PWINDBG_CHECK_CONTROL_C                lpCheckControlCRoutine;
  196.     PWINDBG_READ_PROCESS_MEMORY_ROUTINE    lpReadVirtualMemRoutine;
  197.     PWINDBG_WRITE_PROCESS_MEMORY_ROUTINE   lpWriteVirtualMemRoutine;
  198.     PWINDBG_OLDKD_READ_PHYSICAL_MEMORY     lpReadPhysicalMemRoutine;
  199.     PWINDBG_OLDKD_WRITE_PHYSICAL_MEMORY    lpWritePhysicalMemRoutine;
  200. } WINDBG_OLDKD_EXTENSION_APIS, *PWINDBG_OLDKD_EXTENSION_APIS;
  201.  
  202. typedef
  203. VOID
  204. (WDBGAPI*PWINDBG_OLD_EXTENSION_ROUTINE)(
  205.     HANDLE                  hCurrentProcess,
  206.     HANDLE                  hCurrentThread,
  207.     ULONG                   dwCurrentPc,
  208.     PWINDBG_EXTENSION_APIS  lpExtensionApis,
  209.     PCSTR                   lpArgumentString
  210.     );
  211.  
  212. typedef
  213. VOID
  214. (WDBGAPI*PWINDBG_EXTENSION_ROUTINE)(
  215.     HANDLE                  hCurrentProcess,
  216.     HANDLE                  hCurrentThread,
  217.     ULONG                   dwCurrentPc,
  218.     ULONG                   dwProcessor,
  219.     PCSTR                   lpArgumentString
  220.     );
  221.  
  222. typedef
  223. VOID
  224. (WDBGAPI*PWINDBG_OLDKD_EXTENSION_ROUTINE)(
  225.     ULONG                        dwCurrentPc,
  226.     PWINDBG_OLDKD_EXTENSION_APIS lpExtensionApis,
  227.     PCSTR                        lpArgumentString
  228.     );
  229.  
  230. typedef
  231. VOID
  232. (WDBGAPI*PWINDBG_EXTENSION_DLL_INIT)(
  233.     PWINDBG_EXTENSION_APIS lpExtensionApis,
  234.     USHORT                 MajorVersion,
  235.     USHORT                 MinorVersion
  236.     );
  237.  
  238. typedef
  239. ULONG
  240. (WDBGAPI*PWINDBG_CHECK_VERSION)(
  241.     VOID
  242.     );
  243.  
  244. #define EXT_API_VERSION_NUMBER 4
  245.  
  246. typedef struct EXT_API_VERSION {
  247.     USHORT  MajorVersion;
  248.     USHORT  MinorVersion;
  249.     USHORT  Revision;
  250.     USHORT  Reserved;
  251. } EXT_API_VERSION, *LPEXT_API_VERSION;
  252.  
  253. typedef
  254. LPEXT_API_VERSION
  255. (WDBGAPI*PWINDBG_EXTENSION_API_VERSION)(
  256.     VOID
  257.     );
  258.  
  259. #define IG_KD_CONTEXT               1
  260. #define IG_READ_CONTROL_SPACE       2
  261. #define IG_WRITE_CONTROL_SPACE      3
  262. #define IG_READ_IO_SPACE            4
  263. #define IG_WRITE_IO_SPACE           5
  264. #define IG_READ_PHYSICAL            6
  265. #define IG_WRITE_PHYSICAL           7
  266. #define IG_READ_IO_SPACE_EX         8
  267. #define IG_WRITE_IO_SPACE_EX        9
  268. #define IG_KSTACK_HELP             10
  269. #define IG_SET_THREAD              11
  270. #define IG_READ_MSR                12
  271. #define IG_WRITE_MSR               13
  272.  
  273. typedef struct _tagPROCESSORINFO {
  274.     USHORT      Processor;                // current processor
  275.     USHORT      NumberProcessors;         // total number of processors
  276. } PROCESSORINFO, *PPROCESSORINFO;
  277.  
  278. typedef struct _tagREADCONTROLSPACE {
  279.     USHORT      Processor;
  280.     ULONG       Address;
  281.     ULONG       BufLen;
  282.     UCHAR       Buf[1];
  283. } READCONTROLSPACE, *PREADCONTROLSPACE;
  284.  
  285. typedef struct _tagIOSPACE {
  286.     ULONG       Address;
  287.     ULONG       Length;                   // 1, 2, or 4 bytes
  288.     ULONG       Data;
  289. } IOSPACE, *PIOSPACE;
  290.  
  291. typedef struct _tagIOSPACE_EX {
  292.     ULONG       Address;
  293.     ULONG       Length;                   // 1, 2, or 4 bytes
  294.     ULONG       Data;
  295.     ULONG       InterfaceType;
  296.     ULONG       BusNumber;
  297.     ULONG       AddressSpace;
  298. } IOSPACE_EX, *PIOSPACE_EX;
  299.  
  300. typedef struct _tagPHYSICAL {
  301.     LARGE_INTEGER          Address;
  302.     ULONG                  BufLen;
  303.     UCHAR                  Buf[1];
  304. } PHYSICAL, *PPHYSICAL;
  305.  
  306. typedef struct _tagREAD_WRITE_MSR {
  307.     ULONG       Msr;
  308.     LONGLONG    Value;
  309. } READ_WRITE_MSR, *PREAD_WRITE_MSR;
  310.  
  311. #ifdef __cplusplus
  312. #define CPPMOD extern "C"
  313. #else
  314. #define CPPMOD
  315. #endif
  316.  
  317.  
  318. #define DECLARE_API(s)                             \
  319.     CPPMOD VOID                                    \
  320.     s(                                             \
  321.         HANDLE                 hCurrentProcess,    \
  322.         HANDLE                 hCurrentThread,     \
  323.         ULONG                  dwCurrentPc,        \
  324.         ULONG                  dwProcessor,        \
  325.         PCSTR                  args                \
  326.      )
  327.  
  328. #ifndef NOEXTAPI
  329.  
  330. #define dprintf          (ExtensionApis.lpOutputRoutine)
  331. #define GetExpression    (ExtensionApis.lpGetExpressionRoutine)
  332. #define GetSymbol        (ExtensionApis.lpGetSymbolRoutine)
  333. #define Disassm          (ExtensionApis.lpDisasmRoutine)
  334. #define CheckControlC    (ExtensionApis.lpCheckControlCRoutine)
  335. #define ReadMemory       (ExtensionApis.lpReadProcessMemoryRoutine)
  336. #define WriteMemory      (ExtensionApis.lpWriteProcessMemoryRoutine)
  337. #define GetContext       (ExtensionApis.lpGetThreadContextRoutine)
  338. #define SetContext       (ExtensionApis.lpSetThreadContextRoutine)
  339. #define Ioctl            (ExtensionApis.lpIoctlRoutine)
  340. #define StackTrace       (ExtensionApis.lpStackTraceRoutine)
  341.  
  342.  
  343. #define GetKdContext(ppi) \
  344.     Ioctl( IG_KD_CONTEXT, (PVOID)ppi, sizeof(*ppi) )
  345.  
  346. extern WINDBG_EXTENSION_APIS ExtensionApis;
  347.  
  348. __inline VOID
  349. ReadControlSpace(
  350.     USHORT  processor,
  351.     ULONG   address,
  352.     PVOID   buf,
  353.     ULONG   size
  354.     )
  355. {
  356.     PREADCONTROLSPACE prc;
  357.     prc = (PREADCONTROLSPACE)LocalAlloc(LPTR, sizeof(*prc) + size );
  358.     ZeroMemory( prc->Buf, size );
  359.     prc->Processor = processor;
  360.     prc->Address = (ULONG)address;
  361.     prc->BufLen = size;
  362.     Ioctl( IG_READ_CONTROL_SPACE, (PVOID)prc, sizeof(*prc) + size );
  363.     CopyMemory( buf, prc->Buf, size );
  364.     LocalFree( prc );
  365. }
  366.  
  367. __inline VOID
  368. ReadIoSpace(
  369.     ULONG   address,
  370.     PULONG  data,
  371.     PULONG  size
  372.     )
  373. {
  374.     IOSPACE is;
  375.     is.Address = (ULONG)address;
  376.     is.Length = *size;
  377.     is.Data = 0;
  378.     Ioctl( IG_READ_IO_SPACE, (PVOID)&is, sizeof(is) );
  379.     *data = is.Data;
  380.     *size = is.Length;
  381. }
  382.  
  383. __inline VOID
  384. WriteIoSpace(
  385.     ULONG   address,
  386.     ULONG   data,
  387.     PULONG  size
  388.     )
  389. {
  390.     IOSPACE is;
  391.     is.Address = (ULONG)address;
  392.     is.Length = *size;
  393.     is.Data = data;
  394.     Ioctl( IG_WRITE_IO_SPACE, (PVOID)&is, sizeof(is) );
  395.     *size = is.Length;
  396. }
  397.  
  398. __inline VOID
  399. ReadIoSpaceEx(
  400.     ULONG   address,
  401.     PULONG  data,
  402.     PULONG  size,
  403.     ULONG   interfacetype,
  404.     ULONG   busnumber,
  405.     ULONG   addressspace
  406.     )
  407. {
  408.     IOSPACE_EX is;
  409.     is.Address = (ULONG)address;
  410.     is.Length = *size;
  411.     is.Data = 0;
  412.     is.InterfaceType = interfacetype;
  413.     is.BusNumber = busnumber;
  414.     is.AddressSpace = addressspace;
  415.     Ioctl( IG_READ_IO_SPACE_EX, (PVOID)&is, sizeof(is) );
  416.     *data = is.Data;
  417.     *size = is.Length;
  418. }
  419.  
  420. __inline VOID
  421. WriteIoSpaceEx(
  422.     ULONG   address,
  423.     ULONG   data,
  424.     PULONG  size,
  425.     ULONG   interfacetype,
  426.     ULONG   busnumber,
  427.     ULONG   addressspace
  428.     )
  429. {
  430.     IOSPACE_EX is;
  431.     is.Address = (ULONG)address;
  432.     is.Length = *size;
  433.     is.Data = data;
  434.     is.InterfaceType = interfacetype;
  435.     is.BusNumber = busnumber;
  436.     is.AddressSpace = addressspace;
  437.     Ioctl( IG_WRITE_IO_SPACE_EX, (PVOID)&is, sizeof(is) );
  438.     *size = is.Length;
  439. }
  440.  
  441. __inline VOID
  442. ReadPhysical(
  443.     LARGE_INTEGER       address,
  444.     PVOID               buf,
  445.     ULONG               size,
  446.     PULONG              sizer
  447.     )
  448. {
  449.     PPHYSICAL phy;
  450.     phy = (PPHYSICAL)LocalAlloc(LPTR,  sizeof(*phy) + size );
  451.     ZeroMemory( phy->Buf, size );
  452.     phy->Address = address;
  453.     phy->BufLen = size;
  454.     Ioctl( IG_READ_PHYSICAL, (PVOID)phy, sizeof(*phy) + size );
  455.     *sizer = phy->BufLen;
  456.     CopyMemory( buf, phy->Buf, *sizer );
  457.     LocalFree( phy );
  458. }
  459.  
  460. __inline VOID
  461. WritePhysical(
  462.     LARGE_INTEGER       address,
  463.     PVOID               buf,
  464.     ULONG               size,
  465.     PULONG              sizew
  466.     )
  467. {
  468.     PPHYSICAL phy;
  469.     phy = (PPHYSICAL)LocalAlloc(LPTR, sizeof(*phy) + size );
  470.     ZeroMemory( phy->Buf, size );
  471.     phy->Address = address;
  472.     phy->BufLen = size;
  473.     CopyMemory( phy->Buf, buf, size );
  474.     Ioctl( IG_WRITE_PHYSICAL, (PVOID)phy, sizeof(*phy) + size );
  475.     *sizew = phy->BufLen;
  476.     LocalFree( phy );
  477. }
  478.  
  479. __inline VOID
  480. SetThreadForOperation(
  481.     PULONG Thread
  482.     )
  483. {
  484.     Ioctl(IG_SET_THREAD, (PVOID)Thread, sizeof(ULONG));
  485. }
  486.  
  487. __inline VOID
  488. ReadMsr(
  489.     ULONG       MsrReg,
  490.     ULONGLONG   *MsrValue
  491.     )
  492. {
  493.     PREAD_WRITE_MSR msr;
  494.     LARGE_INTEGER li;
  495.  
  496.     msr = (PREAD_WRITE_MSR)LocalAlloc(LPTR,  sizeof(*msr));
  497.     msr->Msr = MsrReg;
  498.     Ioctl( IG_READ_MSR, (PVOID)msr, sizeof(*msr) );
  499.  
  500.     *MsrValue = msr->Value;
  501.     LocalFree( msr );
  502. }
  503.  
  504. __inline VOID
  505. WriteMsr(
  506.     ULONG       MsrReg,
  507.     ULONGLONG   MsrValue
  508.     )
  509. {
  510.     PREAD_WRITE_MSR msr;
  511.  
  512.     msr = (PREAD_WRITE_MSR)LocalAlloc(LPTR,  sizeof(*msr));
  513.     msr->Msr = MsrReg;
  514.     msr->Value = MsrValue;
  515.     Ioctl( IG_WRITE_MSR, (PVOID)msr, sizeof(*msr) );
  516.     LocalFree( msr );
  517. }
  518.  
  519. #endif
  520.  
  521.  
  522. #ifdef __cplusplus
  523. }
  524. #endif
  525.  
  526. #ifdef __BORLANDC__
  527. #  include <poppack.h>
  528. #endif
  529.  
  530. #pragma option pop
  531. #endif // _WDBGEXTS_
  532.